home *** CD-ROM | disk | FTP | other *** search
/ The Atari Compendium / The Atari Compendium (Toad Computers) (1994).iso / files / umich / tex / texsrc.arc / TEX1.C < prev    next >
C/C++ Source or Header  |  1988-09-14  |  47KB  |  2,266 lines
  1. overlay "tex1"
  2. #define EXTERN extern
  3. #include "texd.h"
  4.  
  5. zshortdisplay ( p ) 
  6. integer p ; 
  7. {r_shortdisplay 
  8.   integer n ; 
  9.   while ( p > memmin ) { 
  10.     if ( ( p >= himemmin ) ) 
  11.     {
  12.       if ( p <= memend ) 
  13.       {
  14.     if ( mem [(long) p ] .hh.b0 != fontinshortd ) 
  15.     {
  16.       if ( ( mem [(long) p ] .hh.b0 < 0 ) || ( mem [(long) p ] .hh.b0 > fontmax ) ) 
  17.       printchar ( 42 ) ; 
  18.       else printesc ( hash [ 3268 + mem [(long) p ] .hh.b0 ] .v.RH ) ; 
  19.       printchar ( 32 ) ; 
  20.       fontinshortd = mem [(long) p ] .hh.b0 ; 
  21.     } 
  22.     printASCII ( mem [(long) p ] .hh.b1 ) ; 
  23.       } 
  24.     } 
  25.     else switch ( mem [(long) p ] .hh.b0 ) 
  26.     {case 0 : 
  27.     case 1 : 
  28.     case 3 : 
  29.     case 8 : 
  30.     case 4 : 
  31.     case 5 : 
  32.     case 13 : 
  33.       print ( 177 ) ; 
  34.       break ; 
  35.     case 2 : 
  36.       printchar ( 124 ) ; 
  37.       break ; 
  38.     case 10 : 
  39.       if ( mem [(long) p + 1 ] .hh .v.LH != 0 ) 
  40.       printchar ( 32 ) ; 
  41.       break ; 
  42.     case 9 : 
  43.       printchar ( 36 ) ; 
  44.       break ; 
  45.     case 6 : 
  46.       shortdisplay ( mem [(long) p + 1 ] .hh .v.RH ) ; 
  47.       break ; 
  48.     case 7 : 
  49.       {
  50.     shortdisplay ( mem [(long) p + 1 ] .hh .v.LH ) ; 
  51.     shortdisplay ( mem [(long) p + 1 ] .hh .v.RH ) ; 
  52.     n = mem [(long) p ] .hh.b1 ; 
  53.     while ( n > 0 ) { 
  54.       if ( mem [(long) p ] .hh .v.RH != 0 ) 
  55.       p = mem [(long) p ] .hh .v.RH ; 
  56.       decr ( n ) ; 
  57.     } 
  58.       } 
  59.       break ; 
  60.     default : 
  61.       ; 
  62.       break ; 
  63.     } 
  64.     p = mem [(long) p ] .hh .v.RH ; 
  65.   } 
  66. } 
  67. zprintfontand ( p ) 
  68. integer p ; 
  69. {r_printfontand 
  70.   if ( p > memend ) 
  71.   printesc ( 178 ) ; 
  72.   else { 
  73.     if ( ( mem [(long) p ] .hh.b0 < 0 ) || ( mem [(long) p ] .hh.b0 > fontmax ) ) 
  74.     printchar ( 42 ) ; 
  75.     else printesc ( hash [ 3268 + mem [(long) p ] .hh.b0 ] .v.RH ) ; 
  76.     printchar ( 32 ) ; 
  77.     printASCII ( mem [(long) p ] .hh.b1 ) ; 
  78.   } 
  79. } 
  80. zprintmark ( p ) 
  81. integer p ; 
  82. {r_printmark 
  83.   printchar ( 123 ) ; 
  84.   if ( ( p < himemmin ) || ( p > memend ) ) 
  85.   printesc ( 178 ) ; 
  86.   else showtokenlis ( mem [(long) p ] .hh .v.RH , 0 , maxprintline - 10 ) ; 
  87.   printchar ( 125 ) ; 
  88. } 
  89. zprintruledim ( d ) 
  90. scaled d ; 
  91. {r_printruledim 
  92.   if ( ( d == - 1073741824 ) ) 
  93.   printchar ( 42 ) ; 
  94.   else printscaled ( d ) ; 
  95. } 
  96. zprintglue ( d , order , s ) 
  97. scaled d ; 
  98. integer order ; 
  99. strnumber s ; 
  100. {r_printglue 
  101.   printscaled ( d ) ; 
  102.   if ( ( order < 0 ) || ( order > 3 ) ) 
  103.   print ( 179 ) ; 
  104.   else if ( order > 0 ) 
  105.   {
  106.     print ( 180 ) ; 
  107.     while ( order > 1 ) { 
  108.       printchar ( 108 ) ; 
  109.       decr ( order ) ; 
  110.     } 
  111.   } 
  112.   else if ( s != 0 ) 
  113.   print ( s ) ; 
  114. } 
  115. zprintspec ( p , s ) 
  116. integer p ; 
  117. strnumber s ; 
  118. {r_printspec 
  119.   if ( ( p < memmin ) || ( p >= lomemmax ) ) 
  120.   printchar ( 42 ) ; 
  121.   else { 
  122.     printscaled ( mem [(long) p + 1 ] .cint ) ; 
  123.     if ( s != 0 ) 
  124.     print ( s ) ; 
  125.     if ( mem [(long) p + 2 ] .cint != 0 ) 
  126.     {
  127.       print ( 181 ) ; 
  128.       printglue ( mem [(long) p + 2 ] .cint , mem [(long) p ] .hh.b0 , s ) ; 
  129.     } 
  130.     if ( mem [(long) p + 3 ] .cint != 0 ) 
  131.     {
  132.       print ( 182 ) ; 
  133.       printglue ( mem [(long) p + 3 ] .cint , mem [(long) p ] .hh.b1 , s ) ; 
  134.     } 
  135.   } 
  136. } 
  137. zprintfamandc ( p ) 
  138. halfword p ; 
  139. {r_printfamandc 
  140.   printesc ( 329 ) ; 
  141.   printint ( mem [(long) p ] .hh.b0 ) ; 
  142.   printchar ( 32 ) ; 
  143.   printASCII ( mem [(long) p ] .hh.b1 ) ; 
  144. } 
  145. zprintdelimit ( p ) 
  146. halfword p ; 
  147. {r_printdelimit 
  148.   integer a ; 
  149.   a = mem [(long) p ] .qqqq .b0 * 256 + mem [(long) p ] .qqqq .b1 ; 
  150.   a = a * 4096 + mem [(long) p ] .qqqq .b2 * 256 + mem [(long) p ] .qqqq .b3 ; 
  151.   if ( a < 0 ) 
  152.   printint ( a ) ; 
  153.   else printhex ( a ) ; 
  154. } 
  155. zprintsubsidi ( p , c ) 
  156. halfword p ; 
  157. ASCIIcode c ; 
  158. {r_printsubsidi 
  159.   if ( ( poolptr - strstart [ strptr ] ) >= depththresho ) 
  160.   {
  161.     if ( mem [(long) p ] .hh .v.RH != 0 ) 
  162.     print ( 183 ) ; 
  163.   } 
  164.   else { 
  165.     {
  166.       strpool [ poolptr ] = c ; 
  167.       incr ( poolptr ) ; 
  168.     } 
  169.     tempptr = p ; 
  170.     switch ( mem [(long) p ] .hh .v.RH ) 
  171.     {case 1 : 
  172.       {
  173.     println () ; 
  174.     printcurrent () ; 
  175.     printfamandc ( p ) ; 
  176.       } 
  177.       break ; 
  178.     case 2 : 
  179.       showinfo () ; 
  180.       break ; 
  181.     case 3 : 
  182.       if ( mem [(long) p ] .hh .v.LH == 0 ) 
  183.       {
  184.     println () ; 
  185.     printcurrent () ; 
  186.     print ( 713 ) ; 
  187.       } 
  188.       else showinfo () ; 
  189.       break ; 
  190.     default : 
  191.       ; 
  192.       break ; 
  193.     } 
  194.     decr ( poolptr ) ; 
  195.   } 
  196. } 
  197. zprintstyle ( c ) 
  198. integer c ; 
  199. {r_printstyle 
  200.   switch ( c / 2 ) 
  201.   {case 0 : 
  202.     printesc ( 714 ) ; 
  203.     break ; 
  204.   case 1 : 
  205.     printesc ( 715 ) ; 
  206.     break ; 
  207.   case 2 : 
  208.     printesc ( 716 ) ; 
  209.     break ; 
  210.   case 3 : 
  211.     printesc ( 717 ) ; 
  212.     break ; 
  213.   default : 
  214.     print ( 718 ) ; 
  215.     break ; 
  216.   } 
  217. } 
  218. zprintskippar ( n ) 
  219. integer n ; 
  220. {r_printskippar 
  221.   switch ( n ) 
  222.   {case 0 : 
  223.     printesc ( 241 ) ; 
  224.     break ; 
  225.   case 1 : 
  226.     printesc ( 242 ) ; 
  227.     break ; 
  228.   case 2 : 
  229.     printesc ( 243 ) ; 
  230.     break ; 
  231.   case 3 : 
  232.     printesc ( 244 ) ; 
  233.     break ; 
  234.   case 4 : 
  235.     printesc ( 245 ) ; 
  236.     break ; 
  237.   case 5 : 
  238.     printesc ( 246 ) ; 
  239.     break ; 
  240.   case 6 : 
  241.     printesc ( 247 ) ; 
  242.     break ; 
  243.   case 7 : 
  244.     printesc ( 248 ) ; 
  245.     break ; 
  246.   case 8 : 
  247.     printesc ( 249 ) ; 
  248.     break ; 
  249.   case 9 : 
  250.     printesc ( 250 ) ; 
  251.     break ; 
  252.   case 10 : 
  253.     printesc ( 251 ) ; 
  254.     break ; 
  255.   case 11 : 
  256.     printesc ( 252 ) ; 
  257.     break ; 
  258.   case 12 : 
  259.     printesc ( 253 ) ; 
  260.     break ; 
  261.   case 13 : 
  262.     printesc ( 254 ) ; 
  263.     break ; 
  264.   case 14 : 
  265.     printesc ( 255 ) ; 
  266.     break ; 
  267.   case 15 : 
  268.     printesc ( 256 ) ; 
  269.     break ; 
  270.   case 16 : 
  271.     printesc ( 257 ) ; 
  272.     break ; 
  273.   case 17 : 
  274.     printesc ( 258 ) ; 
  275.     break ; 
  276.   default : 
  277.     print ( 259 ) ; 
  278.     break ; 
  279.   } 
  280. } 
  281. zshownodelist ( p ) 
  282. integer p ; 
  283. {/* 10 */ r_shownodelist 
  284.   integer n ; 
  285.   real g ; 
  286.   if ( ( poolptr - strstart [ strptr ] ) > depththresho ) 
  287.   {
  288.     if ( p > 0 ) 
  289.     print ( 183 ) ; 
  290.     return ; 
  291.   } 
  292.   n = 0 ; 
  293.   while ( p > memmin ) { 
  294.     println () ; 
  295.     printcurrent () ; 
  296.     if ( p > memend ) 
  297.     {
  298.       print ( 184 ) ; 
  299.       return ; 
  300.     } 
  301.     incr ( n ) ; 
  302.     if ( n > breadthmax ) 
  303.     {
  304.       print ( 185 ) ; 
  305.       return ; 
  306.     } 
  307.     if ( ( p >= himemmin ) ) 
  308.     printfontand ( p ) ; 
  309.     else switch ( mem [(long) p ] .hh.b0 ) 
  310.     {case 0 : 
  311.     case 1 : 
  312.     case 13 : 
  313.       {
  314.     if ( mem [(long) p ] .hh.b0 == 0 ) 
  315.     printesc ( 104 ) ; 
  316.     else if ( mem [(long) p ] .hh.b0 == 1 ) 
  317.     printesc ( 118 ) ; 
  318.     else printesc ( 187 ) ; 
  319.     print ( 188 ) ; 
  320.     printscaled ( mem [(long) p + 3 ] .cint ) ; 
  321.     printchar ( 43 ) ; 
  322.     printscaled ( mem [(long) p + 2 ] .cint ) ; 
  323.     print ( 189 ) ; 
  324.     printscaled ( mem [(long) p + 1 ] .cint ) ; 
  325.     if ( mem [(long) p ] .hh.b0 == 13 ) 
  326.     {
  327.       if ( mem [(long) p ] .hh.b1 != 0 ) 
  328.       {
  329.         print ( 155 ) ; 
  330.         printint ( mem [(long) p ] .hh.b1 + 1 ) ; 
  331.         print ( 191 ) ; 
  332.       } 
  333.       if ( mem [(long) p + 6 ] .cint != 0 ) 
  334.       {
  335.         print ( 192 ) ; 
  336.         printglue ( mem [(long) p + 6 ] .cint , mem [(long) p + 5 ] .hh.b1 , 0 ) ; 
  337.       } 
  338.       if ( mem [(long) p + 4 ] .cint != 0 ) 
  339.       {
  340.         print ( 193 ) ; 
  341.         printglue ( mem [(long) p + 4 ] .cint , mem [(long) p + 5 ] .hh.b0 , 0 ) ; 
  342.       } 
  343.     } 
  344.     else { 
  345.       g = mem [(long) p + 6 ] .gr ; 
  346.       if ( ( g != 0.0 ) && ( mem [(long) p + 5 ] .hh.b0 != 0 ) ) 
  347.       {
  348.         print ( 194 ) ; 
  349.         if ( mem [(long) p + 5 ] .hh.b0 == 2 ) 
  350.         print ( 195 ) ; 
  351.         if ( fabs ( g ) > 20000.0 ) 
  352.         {
  353.           if ( g > 0.0 ) 
  354.           printchar ( 62 ) ; 
  355.           else print ( 196 ) ; 
  356.           printglue ( 20000 * 65536 , mem [(long) p + 5 ] .hh.b1 , 0 ) ; 
  357.         } 
  358.         else printglue ( round ( 65536 * g ) , mem [(long) p + 5 ] .hh.b1 , 0 ) 
  359.         ; 
  360.       } 
  361.       if ( mem [(long) p + 4 ] .cint != 0 ) 
  362.       {
  363.         print ( 190 ) ; 
  364.         printscaled ( mem [(long) p + 4 ] .cint ) ; 
  365.       } 
  366.     } 
  367.     {
  368.       {
  369.         strpool [ poolptr ] = 46 ; 
  370.         incr ( poolptr ) ; 
  371.       } 
  372.       shownodelist ( mem [(long) p + 5 ] .hh .v.RH ) ; 
  373.